package com.quanyan.stadiumScheduler.task;

import com.github.ltsopensource.core.domain.Job;
import com.github.ltsopensource.jobclient.JobClient;
import com.github.ltsopensource.jobclient.domain.Response;
import com.quanyan.stadiumScheduler.constants.GameConstants;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import java.text.SimpleDateFormat;
/**
 * @Since 2016-07-04
 */
public class TimerTaskJob {

    private Logger logger = Logger.getLogger(TimerTaskJob.class);

    @Autowired
    private JobClient jobClient;

    @Value("${lts.node.name}")
    private String ltsNodeName;

    SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    public void executeTask() {

        //每天凌晨2点,定时刷新比赛数量
        Job updateGameNumJob = new Job();
        updateGameNumJob.setTaskId(GameConstants.STADIUM_JOB_ID_REFRESH_GAME_EVENT_NUM);
        updateGameNumJob.setTaskTrackerNodeGroup(this.ltsNodeName); //必须跟配置文件统一
        updateGameNumJob.setNeedFeedback(true);
        updateGameNumJob.setReplaceOnExist(true); // 当任务队列中存在这个任务的时候，是否替换更新
        updateGameNumJob.setRepeatCount(-1);  //无限循环
        updateGameNumJob.setCronExpression("0 0 2 * * ?");  // 每天凌晨2点
        Response updateGameNumJobResponse = jobClient.submitJob(updateGameNumJob);
        logger.warn("定时刷新比赛数量，返回结果: " + updateGameNumJobResponse);


        //用户报名比赛开始通知, 应该10分钟刷新一次, 比赛开始开始推送
        Job gameStartJob = new Job();
        gameStartJob.setTaskId(GameConstants.STADIUM_JOB_ID_GAME_START_REMIND_0_HOUR);
        gameStartJob.setTaskTrackerNodeGroup(this.ltsNodeName); //必须跟配置文件统一
        gameStartJob.setNeedFeedback(true);
        gameStartJob.setReplaceOnExist(true); // 当任务队列中存在这个任务的时候，是否替换更新
        gameStartJob.setRepeatCount(-1);  //无限循环
        gameStartJob.setRepeatInterval(10 * 60 * 1000L);  // 10分钟 执行一次
        Response gameStartJobResponse = jobClient.submitJob(gameStartJob);
        logger.warn("用户报名比赛开始通知，返回结果: " + gameStartJobResponse);


        //mq异常处理, 应该3分钟刷新一次
        Job exceptionMQJob = new Job();
        exceptionMQJob.setTaskId(GameConstants.STADIUM_JOB_ID_REFRESH_EXCEPTION_MQ);
        exceptionMQJob.setTaskTrackerNodeGroup(this.ltsNodeName); //必须跟配置文件统一
        exceptionMQJob.setNeedFeedback(true);
        exceptionMQJob.setReplaceOnExist(true); // 当任务队列中存在这个任务的时候，是否替换更新
        exceptionMQJob.setRepeatCount(-1);  //无限循环
        exceptionMQJob.setRepeatInterval(3 * 60 * 1000L);  // 3分钟 执行一次
        Response exceptionMQResponse = jobClient.submitJob(exceptionMQJob);
        logger.warn("mq异常处理，返回结果: " + exceptionMQResponse);


        //邀请次数每天凌晨恢复
        Job updateInviteCountJob = new Job();
        updateInviteCountJob.setTaskId(GameConstants.STADIUM_JOB_ID_REFRESH_INVITE_COUNT);
        updateInviteCountJob.setTaskTrackerNodeGroup(this.ltsNodeName); //必须跟配置文件统一
        updateInviteCountJob.setNeedFeedback(true);
        updateInviteCountJob.setReplaceOnExist(true); // 当任务队列中存在这个任务的时候，是否替换更新
        updateInviteCountJob.setRepeatCount(-1);  //无限循环
        updateInviteCountJob.setCronExpression("0 0 0 * * ?");  // 每天凌晨处理
        Response updateInviteCountJobResponse = jobClient.submitJob(updateInviteCountJob);
        logger.warn("邀请次数每天凌晨恢复，返回结果: " + updateInviteCountJobResponse);

        //更新个人对抗赛录入比分状态
        Job personPkRecordStatus = new Job();
        personPkRecordStatus.setTaskId(GameConstants.STADIUM_JOB_ID_UPDATE_PERSON_PK_RECORD);
        personPkRecordStatus.setTaskTrackerNodeGroup(this.ltsNodeName); //必须跟配置文件统一
        personPkRecordStatus.setNeedFeedback(true);
        personPkRecordStatus.setReplaceOnExist(true); // 当任务队列中存在这个任务的时候，是否替换更新
        personPkRecordStatus.setRepeatCount(-1);  //无限循环
        personPkRecordStatus.setCronExpression("0 0 0 * * ?");  // 每天凌晨处理
        Response personPkRecordResponse = jobClient.submitJob(personPkRecordStatus);
        logger.warn("查看个人对抗赛录入比分状态，返回结果: " + personPkRecordResponse);


        //关闭比赛开始未报名的比赛
        Job closePersonPkExpireStatus = new Job();
        closePersonPkExpireStatus.setTaskId(GameConstants.STADIUM_JOB_ID_CLOSE_PERSON_PK_EXPIRE);
        closePersonPkExpireStatus.setTaskTrackerNodeGroup(this.ltsNodeName); //必须跟配置文件统一
        closePersonPkExpireStatus.setNeedFeedback(true);
        closePersonPkExpireStatus.setReplaceOnExist(true); // 当任务队列中存在这个任务的时候，是否替换更新
        closePersonPkExpireStatus.setRepeatCount(-1);  //无限循环
        closePersonPkExpireStatus.setRepeatInterval(1 * 30* 60 * 1000L);  // 三十分钟 执行一次
        Response closePersonPkExpireResponse = jobClient.submitJob(closePersonPkExpireStatus);
        logger.warn("关闭比赛开始为报名的比赛，返回结果: " + closePersonPkExpireResponse);

        //内部赛比赛开始时间超过七天还没有编排，系统自动取消
        Job clubGameEventsSystemCancel = new Job();
        clubGameEventsSystemCancel.setTaskId(GameConstants.STADIUM_JOB_ID_SYSTEM_CANCEL_CLUB_GAME_ENENTS_EXPIRE);
        clubGameEventsSystemCancel.setTaskTrackerNodeGroup(this.ltsNodeName); //必须跟配置文件统一
        clubGameEventsSystemCancel.setNeedFeedback(true);
        clubGameEventsSystemCancel.setReplaceOnExist(true); // 当任务队列中存在这个任务的时候，是否替换更新
        clubGameEventsSystemCancel.setRepeatCount(-1);  //无限循环
        clubGameEventsSystemCancel.setRepeatInterval(1 * 30* 60 * 1000L);  // 三十分钟 执行一次
        Response systemCancelRespons = jobClient.submitJob(clubGameEventsSystemCancel);
        logger.warn("系统自动取消超过七天未编排的内部赛，返回结果: " + systemCancelRespons);

    }

}
